package com.atguigu.tingshu.user.service.impl;

import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.user.UserListenProcess;
import com.atguigu.tingshu.model.user.UserListenProcessTable;
import com.atguigu.tingshu.user.dao.UserListenProcessDao;
import com.atguigu.tingshu.user.mapper.UserListenProcessTableMapper;
import com.atguigu.tingshu.user.service.UserListenProcessService;
import com.atguigu.tingshu.vo.user.UserListenProcessVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.security.core.parameters.P;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class UserListenProcessServiceImpl implements UserListenProcessService {

	@Autowired
	private MongoTemplate mongoTemplate;


	/**
	 * MongoDB 查询用户上次声音播放进度
	 * @param trackId
	 * @return
	 */
	@Override
	public Object getTrackBreakSecond(Long trackId) {
		// 获取userId
		Long userId = AuthContextHolder.getUserId();
		// 拼接collectName
		String collectName = "userListenProcess_"+trackId;
		// 从MongoDB查询用户该声音的过往收听数据
		UserListenProcess userListenProcess =
				mongoTemplate.findOne(new Query()
						.addCriteria(Criteria.where("userId").is(userId)
								.and("trackId").is(trackId)),
						UserListenProcess.class,
						collectName);
		// 结果对象是否存在
		if (userListenProcess != null){
			// 听过，查询收听进度后返回
			return userListenProcess.getBreakSecond();
		}
		// 没听过，返回 0 ，从头播放
		return new BigDecimal(0);
	}



	/**
	 * MongoDB
	 * 更新用户上次声音播放进度
	 * @param userListenProcessVo
	 */
	@Override
	public void updateListenProcess(UserListenProcessVo userListenProcessVo) {
		// 校验参数
		if (userListenProcessVo != null){
			// 设置集合名称：对象名 + trackId
			String collectName = "userListenProcess_" + userListenProcessVo.getTrackId();
			// 查询是否听过
			UserListenProcess userListenProcess = mongoTemplate.findOne( // 查询用户收听数据
					new Query().addCriteria( // 查询条件
							Criteria.where("userId").is(AuthContextHolder.getUserId())
									.and("albumId").is(userListenProcessVo.getAlbumId())
									.and("trackId").is(userListenProcessVo.getTrackId())),
					UserListenProcess.class, // 返回结果类型
					collectName); // 集合名称
			if (userListenProcess == null){
				// 没听过 初始化对象
				userListenProcess = new UserListenProcess();
				// 补全属性
				userListenProcess.setId(UUID.randomUUID().toString().replace("-",""));
				userListenProcess.setUserId(AuthContextHolder.getUserId());
				userListenProcess.setAlbumId(userListenProcessVo.getAlbumId());
				userListenProcess.setTrackId(userListenProcessVo.getTrackId());
				userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
				userListenProcess.setCreateTime(userListenProcess.getCreateTime());
			}
			// 听过-覆盖
			userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
			userListenProcess.setUpdateTime(new Date());
			// 直接覆盖：动态集合
			mongoTemplate.save(userListenProcess,collectName);
		}
	}






	@Autowired
	UserListenProcessDao userListenProcessDao;
	/**
	 * MongoDB测试接口
	 */
	@Override
	public void testMongo() {
//		// 新增  &  修改
//		for (long i = 1; i < 11; i++) {
//		UserListenProcess userListenProcess = new UserListenProcess();
//		userListenProcess.setId(i+"");
//		userListenProcess.setUserId(i);
//		userListenProcess.setAlbumId(2L);
//		userListenProcess.setTrackId(3L);
//		userListenProcess.setBreakSecond(new BigDecimal(4));
//		userListenProcess.setIsShow(1);
//		userListenProcess.setCreateTime(new Date());
//		userListenProcess.setUpdateTime(new Date());
////		userListenProcessDao.insert(userListenProcess);
//		userListenProcessDao.save(userListenProcess);
//		}
//		// 条件构造器
		Query query = new Query();
		query.addCriteria(Criteria
				.where("albumId").is(2L));
		query.with(PageRequest.of(1,3, Sort.by(Sort.Order.desc("_id"))));
//		query.with(Sort.by(Sort.Order.asc("_id")));
//		query.skip(1);
//		query.limit(5);
		// 查询
		List<UserListenProcess> userListenProcess =
				mongoTemplate.find(query,
						UserListenProcess.class,
						"userListenProcess");

		for (UserListenProcess u:userListenProcess) {
			System.out.println(u);
		}

//		// 删除
//		userListenProcessDao.deleteAll();
//		Query query = new Query();
//		query.addCriteria(Criteria.where("_id").is("10"));
//		mongoTemplate.remove(query,"userListenProcess");
	}



	@Autowired
	private UserListenProcessTableMapper userListenProcessTableMapper;
	/**
	 * MySQL
	 * 更新用户上次声音播放进度
	 * @param userListenProcessVo
	 */
	@Override
	public void updateListenProcessMysql(UserListenProcessVo userListenProcessVo) {
		// 校验参数
		if (userListenProcessVo == null){
			return;
		}
		// 删除旧的
		userListenProcessTableMapper.delete(
				new LambdaQueryWrapper<UserListenProcessTable>()
						.eq(UserListenProcessTable::getUserId,AuthContextHolder.getUserId())
						.eq(UserListenProcessTable::getAlbumId,userListenProcessVo.getAlbumId())
						.eq(UserListenProcessTable::getTrackId,userListenProcessVo.getTrackId()));
		// 添加新的
		UserListenProcessTable userListenProcessTable = new UserListenProcessTable();
		userListenProcessTable.setUserId(AuthContextHolder.getUserId());
		userListenProcessTable.setAlbumId(userListenProcessVo.getAlbumId());
		userListenProcessTable.setTrackId(userListenProcessVo.getTrackId());
		userListenProcessTable.setBreakSecond(userListenProcessVo.getBreakSecond());
		userListenProcessTableMapper.insert(userListenProcessTable);
	}



	/**
	 * MySQL
	 * 查询用户上次声音播放进度
	 * @param trackId
	 * @return
	 */
	@Override
	public Object getTrackBreakSecondMysql(Long trackId) {
		// 获取当前用户信息
		Long userId = AuthContextHolder.getUserId();
		// 查询用户上一次播放进度
		UserListenProcessTable userListenProcessTable =
				userListenProcessTableMapper.selectOne(
						new LambdaQueryWrapper<UserListenProcessTable>()
								.eq(UserListenProcessTable::getUserId,userId)
								.eq(UserListenProcessTable::getTrackId,trackId));
		// 如果有
		if (userListenProcessTable != null){
			// 上一次听过，返回进度结果
			return userListenProcessTable.getBreakSecond();
		}
		// 没听过 从0播放
		return new BigDecimal(0);
	}
}
